import apiClient from '@/api/axios.js';

export class RoadDisasterApi {

    /**
     * 发布道路灾害信息
     * @param {object} params - 包含灾害信息的对象
     * @param {string} params.disasterType - 灾害类型
     * @param {string} params.disasterInfo - 灾害现场信息/描述
     * @param {number} params.longitude - 经度
     * @param {number} params.latitude - 纬度
     * @param {number} params.userID - 用户ID
     * @param {string} [params.video_url] - 视频URL（可选）
     * @param {'unverified' | 'verified' | 'resolved'} [params.status] - 状态（可选，后端可能有默认值）
     */
    static async addRoadDisaster(params) {
        try {
            // 准备请求体，确保字段与 RoadDisaster 模型匹配
            const requestBody = {
                disasterType: params.disasterType,
                disasterInfo: params.disasterInfo,
                longitude: params.longitude,
                latitude: params.latitude,
                userID: params.userID,
                video_url: params.video_url,
                status: params.status || 'unverified' // 假设默认为 unverified
            };
            console.log("发布道路灾害请求体:", requestBody);
            // 使用 POST /roadDisaster
            const response = await apiClient.post('/roadDisaster', requestBody);
            return response.data; // 假设后端成功时返回数据
        } catch (error) {
            console.error('发布道路灾害失败:', error);
            throw new Error(error.response?.data?.message || error.message || '发布道路灾害失败');
        }
    }

    /**
     * 更新道路灾害信息（包括状态）
     * @param {object} roadDisaster - 完整的 RoadDisaster 对象，必须包含 disasterID
     */
    static async updateRoadDisaster(roadDisaster) {
        try {
            // 确保 disasterID 存在
            if (!roadDisaster || !roadDisaster.disasterID) {
                throw new Error('更新灾害信息时必须提供 disasterID');
            }
            console.log(`更新道路灾害 ${roadDisaster.disasterID} 数据:`, roadDisaster);
            // 使用 PUT /roadDisaster
            const response = await apiClient.put('/roadDisaster', roadDisaster);
            return response.data;
        } catch (error) {
            console.error('更新道路灾害失败:', error);
            throw new Error(error.response?.data?.message || error.message || '更新道路灾害失败');
        }
    }

     /**
      * (辅助方法) 更新灾害状态 - 内部调用 updateRoadDisaster
      * @param {number} disasterID - 灾害ID
      * @param {'unverified' | 'verified' | 'resolved'} status - 新的状态
      */
     static async updateDisasterStatus(disasterID, status) {
         try {
             // 1. 先获取当前灾害的完整信息
             const currentDisasterResponse = await this.getRoadDisasterById(disasterID);
             // 后端返回的是字符串，需要解析
             const currentDisaster = JSON.parse(currentDisasterResponse); // 假设 getRoadDisasterById 返回包含 data 的对象，或者直接返回 RoadDisaster JSON 字符串

             if (!currentDisaster) {
                 throw new Error('找不到要更新状态的灾害信息');
             }

             // 2. 修改状态
             const updatedDisaster = {
                 ...currentDisaster,
                 status: status
             };

             // 3. 调用完整的更新接口
             return await this.updateRoadDisaster(updatedDisaster);

         } catch (error) {
             console.error(`更新灾害 ${disasterID} 状态失败:`, error);
             throw new Error(error.message || `更新灾害状态失败`);
         }
     }


    /**
     * 获取所有道路灾害信息
     * 注意：后端接口未明确分页参数，可能一次性返回所有数据
     * @param {object} [params] - 可选参数 (如果后端支持)
     * @param {number} [params.pageNum] - 页码
     * @param {number} [params.pageSize] - 每页数量
     * @param {'unverified' | 'verified' | 'resolved'} [params.status] - 状态筛选
     */
    static async getAllRoadDisasters(params = {}) {
        try {
            console.log("获取所有道路灾害参数:", params);
            // 使用 GET /roadDisaster
            // 如果后端确实支持这些参数，则传递；否则移除
            const response = await apiClient.get('/roadDisaster', { params });
            // 后端直接返回 String，需要前端解析
            return JSON.parse(response.data || '[]'); // 解析 JSON 字符串
        } catch (error) {
            console.error('获取所有道路灾害失败:', error);
            throw new Error(error.response?.data?.message || error.message || '获取所有道路灾害失败');
        }
    }

    /**
     * 根据 disasterID 获取单个道路灾害信息
     * @param {number} disasterID - 灾害ID
     */
    static async getRoadDisasterById(disasterID) {
        try {
            console.log(`获取道路灾害详情: ${disasterID}`);
            // 使用 GET /roadDisaster/{disasterID}
            const response = await apiClient.get(`/roadDisaster/${disasterID}`);
            // 后端直接返回 String，这里先不解析，让调用方处理
            return response.data;
        } catch (error) {
            console.error('获取道路灾害详情失败:', error);
            throw new Error(error.response?.data?.message || error.message || '获取道路灾害详情失败');
        }
    }

    /**
     * 根据 userID 获取道路灾害信息
     * @param {number} userID - 用户ID
     */
    static async getRoadDisastersByUserId(userID) {
        try {
            console.log(`获取用户 ${userID} 的道路灾害`);
            // 使用 GET /roadDisaster/user/{userID}
            const response = await apiClient.get(`/roadDisaster/user/${userID}`);
            // 后端直接返回 String，需要前端解析
            return JSON.parse(response.data || '[]'); // 解析 JSON 字符串
        } catch (error) {
            console.error('获取用户道路灾害失败:', error);
            throw new Error(error.response?.data?.message || error.message || '获取用户道路灾害失败');
        }
    }

    /**
     * 删除道路灾害信息
     * @param {number} disasterID - 灾害ID
     */
    static async deleteRoadDisaster(disasterID) {
        try {
            console.log(`删除道路灾害: ${disasterID}`);
            // 使用 DELETE /roadDisaster/{disasterID}
            const response = await apiClient.delete(`/roadDisaster/${disasterID}`);
            return response.data; // 假设后端成功时返回一些信息
        } catch (error) {
            console.error('删除道路灾害失败:', error);
            throw new Error(error.response?.data?.message || error.message || '删除道路灾害失败');
        }
    }
}
